<?php
//==============================================
// TextDB 英文函数库 v0.2 Beta版本
//
// 代码所有       PHPText.Net
// 代码作者       黄创钦,tine2cx@163.com
// 联系方式       QQ 233944397
// 本代码开源使用，可以随意修改传播，但请保留本版权
// 声明,谢谢合作！
//==============================================

//设置 《系统基本信息》
define("_TextDB_EXStr_",                  "");         //设置 系统符号（默认：""）
define("_TextDB_REXStr_",                 "");         //设置 系统安全替换符（默认：""）
define("_TextDB_Ver_",                    "v0.1 Beta");  //设置 当前TextDB 函数库的版本
define("_TextDB_GuestID_",                0);            //设置 是否开放浏览用户。[0关/1开]（默认："1"）
define("_TextDB_SavePath_",               "Display/2007/ELIB/TEXTDB/_Database");     //设置 数据库存放路径。（默认："_Data"）【根路径】
define("_TextDB_Bak_",                    "_\$\$");     //设置 数据库回收标志。（默认："_$$"）
define("_TextDB_Lock_",                    "_\$LOC\$");     //设置 数据库回收标志。（默认："_$LOC$"）
define("_TextDB_TBL_",                    ".tbl.php");   //设置 数据库标志。（默认：".tbl.php"）
define("_TextDB_LTBL_",                   ".ltbl.php");   //设置 数据库锁标志。（默认：".ltbl.php"）
define("_TextDB_EXPSize_",                "10485760");   //设置 数据负载以字节为单位。（默认："10M"）
define("_TextDB_LLCount_",                "10");         //设置 数据库尝试解锁次数，超过则提示。（默认："10"）
define("_TextDB_LLMTime_",                "0");          //设置 数据库尝试解锁超时时间。（默认："0"）[0为无限制]

//设置 《初始管理用户数据》
define("_TextDB_InitUserName_",           "PHPText");
define("_TextDB_InitPassword_",           "123456");
define("_TextDB_InitUserEmail_",          "tine2cx@163.com");

//设置 《系统库和表信息》
define("_TextDB_SysDB_System_",           "System");          //设置 系统信息库名称[全]。（默认："System"）
define("_TextDB_SysTBL_UserInfo_",        "UserInfo");        //设置 用户信息表名称[全]。（默认："UserInfo"）
define("_TextDB_SysTBL_DataBaseList_",    "DataBaseList");    //设置 数据库清单名称[全]。（默认："DataBaseList"）
define("_TextDB_SysTBL_BakDataBaseList_", "BakDataBaseList"); //设置 数据库清单名称[全]。（默认："BakDataBaseList"）
define("_TextDB_SysTBL_AllTableList_",    "AllTableList");    //设置 数据表清单名称[全]。（默认："AllTableList"）
define("_TextDB_SysTBL_TableList_",       "TableList");       //设置 数据表清单名称[正常][库]。（默认："TableList"）
define("_TextDB_SysTBL_BakTableList_",    "BakTableList");    //设置 数据表清单名称[回收][库]。（默认："BakTableList"）

/* -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
//下列信息 请勿改动
//设置 《系统存储路径》
define("_TextDB_SQLPath_",             $_SERVER['DOCUMENT_ROOT']."/"._TextDB_SavePath_);

//设置 《系统稳定过滤内容》
define("_TextDB_SysFilter_DBN_",       "*,|,\\,:,\",<,>,?,/, ,.");   //数据库名称过滤
define("_TextDB_SysFilter_TBN_",       "*,|,\\,:,\",<,>,?,/, ,.");   //数据表名称过滤
define("_TextDB_SysFilter_TBC_",       "\n,\r,\t,"._TextDB_EXStr_);   //数据表内容过滤
define("_TextDB_SysFilter_TBCR_",      "\n/,\r/,\t/,"._TextDB_REXStr_);   //数据表内容过滤

//设置 《系统表初始信息》
define("_TextDB_SysTBLF_UserInfo_",       "用户名,密码,邮件,权限,状态,开通日期,截止日期,上次登陆IP,上次登陆时间,拥有库"); //设置 用户信息表初始字段[全]。（默认："编号,用户名,密码,邮件,权限,状态,开通日期,截止日期,上次登陆IP,上次登陆时间,拥有库"）
define("_TextDB_SysTBLF_DataBaseList_",   "库名,建立者,拥有者,开放,建立日期"); //设置 数据库清单初始字段[全]。（默认："编号,库名,拥有者,开放,建立日期"）
define("_TextDB_SysTBLF_BakDataBaseList_","库名,建立者,拥有者,开放,建立日期"); //设置 数据库清单初始字段[全]。（默认："编号,库名,拥有者,开放,建立日期"）
define("_TextDB_SysTBLF_AllTableList_",   "表名,建立者,所属库,开放,建立日期"); //设置 数据表清单初始字段[全]。（默认："编号,表名,所属库,开放,建立日期"）
define("_TextDB_SysTBLF_TableList_",      "表名,建立者,所属库,开放,计数,建立日期"); //设置 数据表清单出事字段[库]。（默认："编号,表名,建立者,开放,计数,建立日期"）
define("_TextDB_SysTBLF_BakTableList_",   "表名,建立者,所属库,开放,计数,建立日期"); //设置 数据表清单出事字段[库]。（默认："编号,表名,建立者,开放,计数,建立日期"）

//跟随 《系统库和表信息》 设置变动
define("_TextDB_SysDBSN_",                _TextDB_SysDB_System_); //设置 禁止建立/删除/回收/修改 【数据库】 名称
define("_TextDB_SysTBSN_",                _TextDB_SysTBL_DataBaseList_.","._TextDB_SysTBL_BakDataBaseList_.","._TextDB_SysTBL_AllTableList_.","._TextDB_SysTBL_TableList_.","._TextDB_SysTBL_BakTableList_); //设置 禁止建立/删除/修改 【数据表】 名称
define("_TextDB_SysTBSN2_",               _TextDB_SysTBL_UserInfo_); //设置 用户  【数据表】 名称
define("_TextDB_SysTBLD_UserInfo_",       _TextDB_InitUserName_.",".md5(_TextDB_InitPassword_).","._TextDB_InitUserEmail_.",9,1,0000-00-00,0000-00-00,0.0.0.0,0000-00-00 00:00:00,*");
define("_TextDB_SysTBLD_DataBaseList_",   _TextDB_SysDB_System_.","._TextDB_InitUserName_.","._TextDB_InitUserName_.",0,0000-00-00");
define("_TextDB_SysTBLD_AllTableList_",   _TextDB_SysTBL_UserInfo_.","._TextDB_InitUserName_.","._TextDB_SysDB_System_.",0,0000-00-00");
define("_TextDB_SysTBLD_TableList_",      _TextDB_SysTBL_UserInfo_.","._TextDB_InitUserName_.","._TextDB_SysDB_System_.",0,0000-00-00");

//写入数据
function TextDB_FileWrite($FileName,$WriteMode,$WirteContent)
{
	$FileHead=fopen($FileName,$WriteMode);
	flock($FileHead,LOCK_EX);
	fwrite($FileHead,$WirteContent);
	flock($FileHead,LOCK_UN);
	fclose($FileHead);
}

//获取文件到数组
//参数一 文件名（相对路径）
function TextDB_FileToArray($FileName)
{
	if(filesize($FileName)<_TextDB_EXPSize_)
	{
		$FileHead=fopen($FileName,"r");
		flock($FileHead,LOCK_EX);
		$FileContent=fread($FileHead,filesize($FileName)+1);
		flock($FileHead,LOCK_UN);
		fclose($FileHead);
		$FileContent = str_replace("\n","\n"._TextDB_EXStr_."TextDB"._TextDB_EXStr_,$FileContent);
		$FileArray   = explode(_TextDB_EXStr_."TextDB"._TextDB_EXStr_,$FileContent);
	}
	else
	{
		$FileArray   = file($FileName);
	}
	return $FileArray;
}

//获取文件中的第一行
//参数一 文件名
function TextDB_ReadOneLine($FileName)
{
		$FileHead = fopen($FileName,"r");
		flock($FileHead,LOCK_EX);
		$FileContent = '';
		rewind($FileHead);
		while(true)
		{
			$Str = fgetc($FileHead);
			if($Str!="\n" && !feof($FileHead))
			{
				$FileContent .= $Str;
			}
			else
			{
				break;
			}
		}

		flock($FileHead,LOCK_UN);
		fclose($FileHead);

		return $FileContent;
}

//TEXTDB安全过滤内容
function TextDB_FilterStr($FilterStr,$Mode=1)
{
	$FilterMode1 = explode(",",_TextDB_SysFilter_TBC_);
	$FilterMode2 = explode(",",_TextDB_SysFilter_TBCR_);
	//判断模式
	if($Mode)  //过滤模式
	{
		$FilterStr = str_replace($FilterMode1,$FilterMode2,$FilterStr);
	}
	else  //还原模式
	{
		$FilterStr = str_replace($FilterMode2,$FilterMode1,$FilterStr);
	}
	return $FilterStr;
}

//检测是否存在
//参数一 检测字串
//参数二 被检测字串[数组，字串]
//参数三 是否忽略大小写[默认，否]
function TextDB_CheckStr($TextDB_CheckStr,$strs,$bs=0)
{
	//检测 被检测字串是否为数组
	if(!is_array($strs))
	{
		$strs = explode(",",$strs);
	}

	//检测 检测字串 是否 存在 被检测字串
	for($CheckNum=0;$CheckNum<sizeof($strs);$CheckNum++)
	{
		//判断 是否 忽略大小写
		if($bs)
		{
			//忽略大小写
			if(strtolower($TextDB_CheckStr)==strtolower($strs[$CheckNum]))
			{
				return true;
			}
		}
		else
		{
			//非忽略大小写
			if($TextDB_CheckStr==$strs[$CheckNum])
			{
				return true;
			}
		}
	}
	return false;
}

//按照字段排序
//参数一 排序数据内容(内容必须是TextDB查询数据格式)
//参数二 排序字段
function TextDB_OrderData($OrderData,$OrderFields)
{
	if($OrderData)
	{
		//数据大小
		$OrderDataSize = sizeof($OrderData);

		//获取字段数据进行排序
		foreach($OrderData as $key=>$Data)
		{
			$OrderList[$key] = $Data[$OrderFields];
		}

		asort($OrderList);

		//从新排序数据
		foreach($OrderList as $key=>$Data)
		{
			$TempOrderData[] = $OrderData[$key];
		}

		return $TempOrderData;
	}
}

//启动TextDB
function TextDB_Init()
{
	if(!isset($GLOBALS["TextDB_Init"]) or empty($GLOBALS["TextDB_Init"]))
	{
		//检测数据库存放路径
		if(!file_exists(_TextDB_SQLPath_) or !is_dir(_TextDB_SQLPath_))
		{
			mkdir(_TextDB_SQLPath_,0777);
		}

		//设置初始状态
		$GLOBALS["TextDB_Init"]      = 1;
		$GLOBALS["TextDB_Link_DB"]   = "";
		$GLOBALS["TextDB_Error_ID"]  = 0;
		$GLOBALS["TextDB_LLC_NOW"]   = 0;

		//初始化系统
		//创建系统库
		TextDB_CreateDB(_TextDB_SysDB_System_);
		TextDB_ConnectDB(_TextDB_SysDB_System_);

		//创建用户信息表
		if(TextDB_CreateTable(_TextDB_SysTBL_UserInfo_,_TextDB_SysTBLF_UserInfo_))
		{
			//插入初始用户数据
			TextDB_InsertData(_TextDB_SysTBL_UserInfo_,_TextDB_SysTBLF_UserInfo_,explode(",",_TextDB_SysTBLD_UserInfo_));
		}

		//创建数据库清单
		if(TextDB_CreateTable(_TextDB_SysTBL_DataBaseList_,_TextDB_SysTBLF_DataBaseList_))
		{
			//插入初始数据
			TextDB_InsertData(_TextDB_SysTBL_DataBaseList_,_TextDB_SysTBLF_DataBaseList_,explode(",",_TextDB_SysTBLD_DataBaseList_));
		}

		//创建数据表清单[回收][库]
		TextDB_CreateTable(_TextDB_SysTBL_BakDataBaseList_,_TextDB_SysTBLF_BakDataBaseList_);

		//创建数据表清单[全]
		if(TextDB_CreateTable(_TextDB_SysTBL_AllTableList_,_TextDB_SysTBLF_AllTableList_))
		{
			//插入初始数据
			TextDB_InsertData(_TextDB_SysTBL_AllTableList_,_TextDB_SysTBLF_AllTableList_,explode(",",_TextDB_SysTBLD_AllTableList_));
		}

		//创建数据表清单[正常][库]
		if(TextDB_CreateTable(_TextDB_SysTBL_TableList_,_TextDB_SysTBLF_TableList_))
		{
			//插入初始数据
			TextDB_InsertData(_TextDB_SysTBL_TableList_,_TextDB_SysTBLF_TableList_,explode(",",_TextDB_SysTBLD_TableList_));
		}

		//创建数据表清单[回收][库]
		TextDB_CreateTable(_TextDB_SysTBL_BakTableList_,_TextDB_SysTBLF_BakTableList_);

		TextDB_ConnectClose();

		return true;
	}
	else
	{
		return false;
	}
}

//获取当前连接库名称
function TextDB_GetLinkDB()
{
	return $GLOBALS["TextDB_Link_DB"];
}

//关闭TextDB
function TextDB_Close()
{
	if($GLOBALS["TextDB_Init"])
	{
		unset($GLOBALS["TextDB_Init"],$GLOBALS["TextDB_Link_DB"],$GLOBALS["TextDB_Error_ID"],$GLOBALS["TextDB_Login_ID"]);
		return true;
	}
	else
	{
		return false;
	}
}

//获取当前版本号
function TextDB_Ver()
{
	return _TextDB_Ver_;
}

//提示信息
function TextDB_Alert($mes)
{
	return "<script type='text/javascript'>alert('".$mes."')</script>";
}

//运行 TDL(Text Database Language)
function TextDB_RunTDL($TDLStr)
{
	if($GLOBALS["TextDB_Init"])
	{
		eval(stripslashes($TDLStr));
		return true;
	}
	else
	{
		return false;
	}
}

//连接数据库
function TextDB_ConnectDB($DBName)
{
	//检测数据库名称是否符合要求
	if(TextDB_CheckStr($DBName,_TextDB_SysFilter_DBN_))
	{
		return false;
	}
	if($GLOBALS["TextDB_Init"])
	{
		$TempDBName = $DBName;
		$DBName     = _TextDB_SQLPath_."/_".$TempDBName;
		$BakDBName  = _TextDB_SQLPath_."/_".$TempDBName._TextDB_Bak_;
		if(empty($GLOBALS["TextDB_Link_DB"]))
		{
			//检测 连接库 是不是 可用库
			if(file_exists($DBName) && is_dir($DBName))
			{
				$GLOBALS["TextDB_Link_DB"]=$TempDBName;
				return true;
			//检测 连接库 是不是 回收库
			}
			elseif(file_exists($BakDBName) && is_dir($BakDBName))
			{
				$GLOBALS["TextDB_Link_DB"]=$TempDBName._TextDB_Bak_;
				return true;
			}
			else
			{
				return false;
			}
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}

//关闭数据库连接
function TextDB_ConnectClose()
{
	if($GLOBALS["TextDB_Init"])
	{
		if(isset($GLOBALS["TextDB_Link_DB"]))
		{
			$GLOBALS["TextDB_Link_DB"]="";
			return true;
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}

//检测数据库是否存在
//
//
function TextDB_CheckDB($DBName)
{
	//检测数据库名称是否符合要求
	if(TextDB_CheckStr($DBName,_TextDB_SysFilter_DBN_))
	{
		return false;
	}
	if($GLOBALS["TextDB_Init"] and !empty($DBName))
	{
		$TempDBName = $DBName;
		$DBName     = _TextDB_SQLPath_."/_".$TempDBName;
		$BakDBName  = _TextDB_SQLPath_."/_".$TempDBName._TextDB_Bak_;

		if(!file_exists($DBName) and !is_dir($DBName))
		{
			if(file_exists($BakDBName) and is_dir($BakDBName))
			{
				return true;
			}
			else
			{
				return false;
			}
		}
		else
		{
			return true;
		}
	}
	else
	{
		return false;
	}
}

//建立数据库
//
//
function TextDB_CreateDB($DBName,$DBOpen=0)
{
	//检测数据库名称是否符合要求
	if(TextDB_CheckStr($DBName,_TextDB_SysFilter_DBN_))
	{
		return false;
	}
	if($GLOBALS["TextDB_Init"] and !empty($DBName))
	{
		$TempDBName = $DBName;
		$DBName     = _TextDB_SQLPath_."/_".$DBName;

		if(file_exists($DBName) and is_dir($DBName))
		{
			return false;
		}
		else
		{
			//建立数据库
			mkdir($DBName,0777);
			$TempPath = $GLOBALS["TextDB_Link_DB"];
			if(isset($GLOBALS["TextDB_Link_DB"]))
			{
				TextDB_ConnectClose();
			}

			//增加 新增库 数据表 清单
			TextDB_ConnectDB($TempDBName);
			TextDB_CreateTable(_TextDB_SysTBL_TableList_,_TextDB_SysTBLF_TableList_);
			TextDB_CreateTable(_TextDB_SysTBL_BakTableList_,_TextDB_SysTBLF_BakTableList_);
			TextDB_ConnectClose();

			//增加 新增库 记录
			TextDB_ConnectDB(_TextDB_SysDB_System_);
			TextDB_InsertData(_TextDB_SysTBL_DataBaseList_,_TextDB_SysTBLF_DataBaseList_,explode(",",$TempDBName.","._TextDB_InitUserName_.","._TextDB_InitUserName_.",".$DBOpen.",".date("Y-m-d")));
			TextDB_ConnectClose();

			//回到 原登陆库
			if(isset($TempPath))
			{
				TextDB_ConnectDB($TempPath);
			}
			return true;
		}
	}
	else
	{
		return false;
	}
}

//删除数据库
//
//
function TextDB_DeleteDB($DBName,$RM=1)
{
	//检测数据库名称是否符合要求
	if(TextDB_CheckStr($DBName,_TextDB_SysFilter_DBN_))
	{
		return false;
	}
	if($GLOBALS["TextDB_Init"] and !empty($DBName))
	{
		$TempDBName = $DBName;
		$DBName     = _TextDB_SQLPath_."/_".$TempDBName;
		$BakDBName  = _TextDB_SQLPath_."/_".$TempDBName._TextDB_Bak_;

		//检测 是否为系统库
		if(TextDB_CheckStr($TempDBName,_TextDB_SysDBSN_,1))
		{
			return false;
		}

		$bak=0;
		if(!file_exists($DBName) and !is_dir($DBName))
		{
			if(file_exists($BakDBName) and is_dir($BakDBName))
			{
				$DBName = $BakDBName;
				$bak=1;
			}
			else
			{
				return false;
			}
		}
		TextDB_ConnectDB(_TextDB_SysDB_System_);
		if($RM)
		{
			$mydirectory = opendir($DBName);
			while($entryname=readdir($mydirectory))
			{
				switch (true) {
					case ($entryname=="."):
						break;
					case ($entryname==".."):
						break;
					case (is_dir($DBName."/".$entryname)):
						TextDB_DeleteDB($DBName."/".$entryname);
						break;
					default:
						unlink($DBName."/".$entryname);
						break;
				}
			}
			closedir($mydirectory);
			rmdir($DBName);
			if($bak){
				TextDB_DeleteData(_TextDB_SysTBL_BakDataBaseList_,"库名",$TempDBName);
			}
		}
		else
		{
			rename($DBName,$DBName._TextDB_Bak_);
			TextDB_InsertData(_TextDB_SysTBL_BakDataBaseList_,_TextDB_SysTBLF_BakDataBaseList_,explode(",",$TempDBName.","._TextDB_InitUserName_.","._TextDB_InitUserName_.",0,".date("Y-m-d")));
		}

		//删除 数据库 记录
		TextDB_DeleteData(_TextDB_SysTBL_DataBaseList_,"库名",$TempDBName);
		TextDB_ConnectClose();

		return true;
	}
	else
	{
		return false;
	}
}

//恢复 数据库
function TextDB_ResumeDB($DBName)
{
	//检测数据库名称是否符合要求
	if(TextDB_CheckStr($DBName,_TextDB_SysFilter_DBN_))
	{
		return false;
	}
	if($GLOBALS["TextDB_Init"])
	{
		$TempDBName = $DBName;
		$DBName     = _TextDB_SQLPath_."/_".$TempDBName._TextDB_Bak_;
		$NewDBName  = _TextDB_SQLPath_."/_".$TempDBName;

		//检测 是否为系统库
		if(TextDB_CheckStr($TempDBName,_TextDB_SysDBSN_,1))
		{
			return false;
		}

		if(file_exists($NewDBName) and is_dir($NewDBName))
		{
			return false;
		}

		if(!file_exists($DBName) and !is_dir($DBName))
		{
			return false;
		}
		else
		{
			rename($DBName,$NewDBName);

			TextDB_ConnectDB(_TextDB_SysDB_System_);
			TextDB_DeleteData(_TextDB_SysTBL_BakDataBaseList_,"库名",$TempDBName);
			TextDB_InsertData(_TextDB_SysTBL_DataBaseList_,_TextDB_SysTBLF_DataBaseList_,explode(",",$TempDBName.","._TextDB_InitUserName_.","._TextDB_InitUserName_.",0,".date("Y-m-d")));
			TextDB_ConnectClose();

			return true;
		}
	}
	else
	{
		return false;
	}
}

//修改数据库名
//
//
//2007-08-28 修正修改数据库后数据库连接问题
function TextDB_ChangeDB($DBName,$DBOpen,$NewDBName,$NewDBOpen)
{
	//检测数据库名称是否符合要求
	if(TextDB_CheckStr($DBName,_TextDB_SysFilter_DBN_))
	{
		return false;
	}
	//检测新数据库名称是否符合要求
	if(TextDB_CheckStr($NewDBName,_TextDB_SysFilter_DBN_))
	{
		return false;
	}
	if($GLOBALS["TextDB_Init"] and !empty($DBName) and !empty($NewDBName))
	{

		$TempDBName    = $DBName;
		$TempNewDBName = $NewDBName;
		$DBName        = _TextDB_SQLPath_."/_".$TempDBName;
		$NewDBName     = _TextDB_SQLPath_."/_".$TempNewDBName;

		//检测 是否为系统库
		if(TextDB_CheckStr($TempDBName,_TextDB_SysDBSN_,1) or TextDB_CheckStr($TempNewDBName,_TextDB_SysDBSN_,1))
		{
			return false;
		}

		//检测 修改库是否存在，新建库是否存在
		if(!file_exists($DBName) and !is_dir($DBName))
		{
			return false;
		}
		else
		{
			if($DBName!=$NewDBName)
			{
				rename($DBName,$NewDBName);
			}

			if(isset($GLOBALS["TextDB_Link_DB"]))
			{
				$BakDBLink=$GLOBALS["TextDB_Link_DB"];
				TextDB_ConnectClose();
			}

			$Fields[] = "库名";
			$Fields[] = "开放";

			$DB[]     = $TempDBName;
			$DB[]     = $DBOpen;

			$NewDB[]  = $TempNewDBName;
			$NewDB[]  = $NewDBOpen;

			//更新数据
			TextDB_ConnectDB(_TextDB_SysDB_System_);
			TextDB_ChangeData(_TextDB_SysTBL_DataBaseList_,$Fields,$DB,$Fields,$NewDB);
			TextDB_ConnectClose();

			//更新 库中表对应的库
			TextDB_ConnectDB($TempNewDBName);
			TextDB_ChangeData(_TextDB_SysTBL_TableList_,"所属库",$TempDBName,"所属库",$TempNewDBName);
			TextDB_ChangeData(_TextDB_SysTBL_BakTableList_,"所属库",$TempDBName,"所属库",$TempNewDBName);
			TextDB_ConnectClose();

			//如果修改的是正在使用的数据库名称，就更新
			if($BakDBLink==$TempDBName)
			{
				TextDB_ConnectDB($TempNewDBName);
			}
			else
			{
				TextDB_ConnectDB($BakDBLink);
			}
			return true;
		}
	}
	else
	{
		return false;
	}
}

//复制数据库
//
//
function TextDB_CopyDB($DBName,$NewDBName)
{
	//检测数据库名称是否符合要求
	if(TextDB_CheckStr($DBName,_TextDB_SysFilter_DBN_))
	{
		return false;
	}
	//检测新数据库名称是否符合要求
	if(TextDB_CheckStr($NewDBName,_TextDB_SysFilter_DBN_))
	{
		return false;
	}

	if($GLOBALS["TextDB_Init"])
	{
		$TempDBName    = $DBName;
		$TempNewDBName = $NewDBName;
		$DBName        = _TextDB_SQLPath_."/_".$DBName;
		$NewDBName     = _TextDB_SQLPath_."/_".$NewDBName;

		//检测 是否为系统库
		if(TextDB_CheckStr($TempDBName,_TextDB_SysDBSN_,1) or TextDB_CheckStr($TempNewDBName,_TextDB_SysDBSN_,1))
		{
			return false;
		}

		if((!file_exists($DBName) and !is_dir($DBName)) or (file_exists($NewDBName) and is_dir($NewDBName)))
		{
			return false;
		}
		else
		{
			//获取原 数据库 信息
			TextDB_ConnectDB(_TextDB_SysDB_System_);
			$dbinfo=TextDB_SearchData(_TextDB_SysTBL_DataBaseList_,"库名",$TempDBName);
			TextDB_ConnectClose();

			//建立新数据库
			TextDB_CreateDB($TempNewDBName,$dbinfo[0]["开放"]);

			$mydirectory = opendir($DBName);
			while($entryname=readdir($mydirectory))
			{
				switch (true)
				{
					case ($entryname=="."):
						break;
					case ($entryname==".."):
						break;
					case (is_dir($DBName."/".$entryname)):
						//建立目录
						mkdir($NewDBName."/".$entryname,0777);
						TextDB_CopyDB($DBName."/".$entryname);
						break;
					default:
						copy($DBName."/".$entryname,$NewDBName."/".$entryname);
						break;
				}
			}
			closedir($mydirectory);

			if(isset($GLOBALS["TextDB_Link_DB"]))
			{
				$BakDBLink=$GLOBALS["TextDB_Link_DB"];
				TextDB_ConnectClose();
			}

			//更新 库中表对应的库
			TextDB_ConnectDB($TempNewDBName);
			TextDB_ChangeData(_TextDB_SysTBL_TableList_,"所属库",$TempDBName,"所属库",$TempNewDBName);
			TextDB_ChangeData(_TextDB_SysTBL_BakTableList_,"所属库",$TempDBName,"所属库",$TempNewDBName);
			TextDB_ConnectClose();

			//如果修改的是正在使用的数据库名称，就更新
			if($BakDBLink==$TempDBName)
			{
				TextDB_ConnectDB($TempNewDBName);
			}
			else
			{
				TextDB_ConnectDB($BakDBLink);
			}

			return true;
		}
	}
	else
	{
		return false;
	}
}

//清空 数据库
function TextDB_CleanDB($DBName,$CleanMode)
{
	//检测数据库名称是否符合要求
	if(TextDB_CheckStr($DBName,_TextDB_SysFilter_DBN_))
	{
		return false;
	}

	if($GLOBALS["TextDB_Init"])
	{
		$TempDBName = $DBName;
		$DBName     = _TextDB_SQLPath_."/_".$DBName;

		//检测 是否为系统库
		if(TextDB_CheckStr($TempDBName,_TextDB_SysDBSN_,1))
		{
			return false;
		}

		if($CleanMode<0 or $CleanMode>2)
		{
			return false;
		}

		if(!file_exists($DBName) and !is_dir($DBName))
		{
			return false;
		}
		else
		{
			//清空 [可用库]
			function _CleanDB($db)
			{
				TextDB_ConnectDB($db);
				$tablelist=TextDB_SearchData(_TextDB_SysTBL_TableList_);
				for($dbSN=0;$dbSN<sizeof($tablelist);$dbSN++)
				{
					TextDB_DeleteTable($tablelist[$dbSN]["表名"]);
				}
				TextDB_ConnectClose();
			}

			//清空 [回收库]
			function _CleanBakDB($db)
			{
				TextDB_ConnectDB($db);
				$baktablelist=TextDB_SearchData(_TextDB_SysTBL_BakTableList_);
				for($dbSN=0;$dbSN<sizeof($baktablelist);$dbSN++)
				{
					TextDB_DeleteTable($baktablelist[$dbSN]["表名"]);
				}
				TextDB_ConnectClose();
			}

			switch($CleanMode)
			{
				case 0:
					_CleanDB($TempDBName);
					_CleanBakDB($TempDBName);
					break;
				case 1:
					_CleanDB($TempDBName);
					break;
				case 2:
					_CleanBakDB($TempDBName);
					break;
			}
			return true;
		}
	}
	else
	{
		return false;
	}
}

//检测表是否存在
function TextDB_CheckTable($TableName)
{
	//检测数据表名称是否符合要求
	if(TextDB_CheckStr($TableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}

	if($GLOBALS["TextDB_Init"])
	{
		if(isset($GLOBALS["TextDB_Link_DB"]))
		{
			$TempTableName = $TableName;
			$TableName     = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_TBL_;
			$BakTableName  = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Bak_._TextDB_TBL_;

			if(!file_exists($TableName) and !is_file($TableName))
			{
				if(file_exists($BakTableName) and is_file($BakTableName))
				{
					return true;
				}
				else
				{
					return false;
				}
			}
			else
			{
				return true;
			}
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}

//数据表锁定状态
function TextDB_isLockTable($TableName)
{
	$LockFile = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TableName._TextDB_Lock_._TextDB_TBL_;
	if(file_exists($LockFile) && is_file($LockFile))
	{
		$GLOBALS["TextDB_LLC_NOW"]++;
		if($GLOBALS["TextDB_LLC_NOW"]>_TextDB_LLCount_)
		{
			$GLOBALS["TextDB_LLC_NOW"] = 0;
			return false;
		}
		return true;
	}
	else
	{
		$GLOBALS["TextDB_LLC_NOW"] = 0;
		return false;
	}
}

//数据表锁定
function TextDB_LockTable($TableName)
{
	if($TableName!=='')
	{
		set_time_limit(0);
		@touch(_TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TableName._TextDB_Lock_._TextDB_TBL_);
		return true;
	}
	else
	{
		return false;
	}
}

//数据表解锁
function TextDB_UnlockTable($TableName)
{
	if($TableName!=='')
	{
		@unlink(_TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TableName._TextDB_Lock_._TextDB_TBL_);
		return true;
	}
	else
	{
		return false;
	}
}


//创建数据表
//
//
function TextDB_CreateTable($TableName,$Fields,$Open=0,$HeaderInfo=null)
{
	//检测数据表名称是否符合要求
	if(TextDB_CheckStr($TableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}
	$Fields = TextDB_FilterStr($Fields);
	if($GLOBALS["TextDB_Init"]){
		if(isset($GLOBALS["TextDB_Link_DB"]))
		{
			//获取 数据表 名称和所属库
			$TempTableName = $TableName;
			$TableName     = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_TBL_;

			//查找 数据表 是否存在
			if(file_exists($TableName) and is_file($TableName))
			{
				//存在的情况
				return false;
			}
			else
			{
				//建立 数据表
				touch($TableName);

				//设置 数据表 权限
				chmod($TableName,0777);

				//如果 字段信息 是 数组 ,就合并
				if(is_array($Fields))
				{
					$Fields=implode(",",$Fields);
				}

				//过滤 字段信息 中系统冲突字符
				$Fields=str_replace(_TextDB_EXStr_,_TextDB_REXStr_,$Fields);

				//替换 字段信息 中的 默认分割字段
				$Fields=str_replace(",",_TextDB_EXStr_,$Fields);

				//检测是否字定义 安全信息,空就自添加
				if($HeaderInfo=="")
				{
					$HeaderInfo = "die(\"TextDB "._TextDB_Ver_."\");";
				}

				//过滤 安全信息 中系统冲突字符
				$HeaderInfo = str_replace("<?php","",$HeaderInfo);
				$HeaderInfo = str_replace("?>","",$HeaderInfo);
				$HeaderInfo = str_replace(_TextDB_EXStr_,_TextDB_REXStr_,$HeaderInfo);

				//添加 安全信息 可执行
				$HeaderInfo = "<?php ".$HeaderInfo." ?>";

				//融合 安全信息 和 字段信息
				$Fields = $HeaderInfo._TextDB_EXStr_.$Fields._TextDB_EXStr_;

				//建立 数据表
				TextDB_FileWrite($TableName,"a",$Fields);

				//检测 是否为系统表
				$ok=1;
				if(TextDB_CheckStr($TempTableName,_TextDB_SysTBSN_,1))
				{
					$ok=0;
				}

				//如果不是
				if($ok)
				{
					TextDB_InsertData(_TextDB_SysTBL_TableList_,_TextDB_SysTBLF_TableList_,explode(",",$TempTableName.","._TextDB_InitUserName_.",".$GLOBALS["TextDB_Link_DB"].",".$Open.",0,".date("Y-m-d")));
				}
				return true;
			}
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}

//删除数据表
//$TableName 数据表名称
//$RM 是否回收
function TextDB_DeleteTable($TableName,$RM=1)
{
	//检测数据表名称是否符合要求
	if(TextDB_CheckStr($TableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}

	if($GLOBALS["TextDB_Init"])
	{
		if(isset($GLOBALS["TextDB_Link_DB"]))
		{
			$TempTableName = $TableName;
			$TableName     = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_TBL_;
			$BakTableName  = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Bak_._TextDB_TBL_;
			$LockFile      = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Lock_._TextDB_TBL_;

			//检测 是否为系统表
			if(TextDB_CheckStr($TempTableName,_TextDB_SysTBSN_,1))
			{
				return false;
			}

			$bak = 0;
			if(!file_exists($TableName) and !is_file($TableName))
			{
				if(file_exists($BakTableName) and is_file($BakTableName))
				{
					$TableName = $BakTableName;
					$bak       = 1;
				}
				else
				{
					return false;
				}
			}

			//检测文件是否被锁定
			while(TextDB_isLockTable($TempTableName))
			{
				usleep(50);
			}

			//锁定文件
			TextDB_LockTable($TempTableName);

			if($RM)
			{
				unlink($TableName);
				if($bak)
				{
					TextDB_DeleteData(_TextDB_SysTBL_BakTableList_,"表名",$TempTableName);
				}
			}
			else
			{
				rename($TableName,$BakTableName);
				TextDB_InsertData(_TextDB_SysTBL_BakTableList_,_TextDB_SysTBLF_BakTableList_,explode(",",$TempTableName.","._TextDB_InitUserName_.",".$GLOBALS["TextDB_Link_DB"].",0,0000-00-00"));
			}
			TextDB_DeleteData(_TextDB_SysTBL_TableList_,"表名",$TempTableName);

			//释放文件
			TextDB_UnlockTable($TempTableName);

			return true;
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}

//还原数据表
//
//
function TextDB_ResumeTable($TableName)
{
	//检测数据表名称是否符合要求
	if(TextDB_CheckStr($TableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}

	if($GLOBALS["TextDB_Init"])
	{
		if(isset($GLOBALS["TextDB_Link_DB"]))
		{
			$TempTableName = $TableName;
			$TableName     = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_TBL_;
			$BakTableName  = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Bak_._TextDB_TBL_;

			//检测 是否为系统表
			if(TextDB_CheckStr($TempTableName,_TextDB_SysTBSN_,1))
			{
				return false;
			}

			if(file_exists($TableName) && is_file($TableName))
			{
				return false;
			}

			if(!file_exists($BakTableName) && !is_file($BakTableName))
			{
				return false;
			}
			else
			{
				//检测文件是否被锁定
				while(TextDB_isLockTable($TempTableName))
				{
					usleep(50);
				}

				//锁定文件
				TextDB_LockTable($TempTableName);

				//还原数据表
				rename($BakTableName,$TableName);

				//数据表记录操作
				TextDB_DeleteData(_TextDB_SysTBL_BakTableList_,"表名",$TempTableName);
				TextDB_InsertData(_TextDB_SysTBL_TableList_,_TextDB_SysTBLF_TableList_,explode(",",$TempTableName.","._TextDB_InitUserName_.",".$GLOBALS["TextDB_Link_DB"].",0,0000-00-00"));

				//释放文件
				TextDB_UnlockTable($TempTableName);

				return true;
			}
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}

//修改数据表
function TextDB_ChangeTable($TableName,$TableFields=null,$TableOpen=null,$NewTableName,$NewTableFields=null,$NewTableOpen=null)
{
	//检测数据表名称是否符合要求
	if(TextDB_CheckStr($TableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}
	//检测新数据表名称是否符合要求
	if(TextDB_CheckStr($NewTableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}

	if($GLOBALS["TextDB_Init"])
	{
		if(isset($GLOBALS["TextDB_Link_DB"]))
		{

			$TempTableName    = $TableName;
			$TempNewTableName = $NewTableName;
			$TableName        = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_TBL_;
			$NewTableName     = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempNewTableName._TextDB_TBL_;
			$LockFile         = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Lock_._TextDB_TBL_;

			//检测 是否为系统表
			if(TextDB_CheckStr($TempTableName,_TextDB_SysTBSN2_,1) || TextDB_CheckStr($TempNewTableName,_TextDB_SysTBSN2_,1) || TextDB_CheckStr($TempTableName,_TextDB_SysTBSN_,1) || TextDB_CheckStr($TempNewTableName,_TextDB_SysTBSN_,1))
			{
				return false;
			}

			if(!file_exists($TableName) && !is_file($TableName))
			{
				return false;
			}
			else
			{
				//检测文件是否被锁定
				while(TextDB_isLockTable($TempTableName))
				{
					usleep(50);
				}

				//锁定文件
				TextDB_LockTable($TempTableName);

				//修改表名
				if($TableName!=$NewTableName)
				{
					rename($TableName,$NewTableName);
				}

				$Fields[]   = "表名";
				$Fields[]   = "开放";

				$Table[]    = $TempTableName;
				$Table[]    = $TableOpen;

				$NewTable[] = $TempNewTableName;
				$NewTable[] = $NewTableOpen;

				TextDB_ChangeData(_TextDB_SysTBL_TableList_,$Fields,$Table,$Fields,$NewTable);

				//修改字段
				if($TableFields!=$NewTableFields)
				{
					$NewTableFields = TextDB_FilterStr($NewTableFields);
					_TextDB_UpdateFields($TempNewTableName,$NewTableFields);
				}

				//释放文件
				TextDB_UnlockTable($TempTableName);

				return true;
			}
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}

//复制数据表
//被复制的数据表
//复制的数据表
function TextDB_CopyTable($TableName,$NewTableName)
{
	//检测数据表名称是否符合要求
	if(TextDB_CheckStr($TableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}

	//检测新数据表名称是否符合要求
	if(TextDB_CheckStr($NewTableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}

	if($GLOBALS["TextDB_Init"])
	{
		if(isset($GLOBALS["TextDB_Link_DB"]))
		{
			$TempTableName    = $TableName;
			$TempNewTableName = $NewTableName;
			$TableName        = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_TBL_;
			$NewTableName     = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempNewTableName._TextDB_TBL_;
			$LockFile         = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Lock_._TextDB_TBL_;

			//检测 是否为系统表
			if(TextDB_CheckStr($TempTableName,_TextDB_SysTBSN_,1) || TextDB_CheckStr($TempNewTableName,_TextDB_SysTBSN_,1))
			{
				return false;
			}

			//检测 数据表是否存在
			if((!file_exists($TableName) && !is_file($TableName)) && (file_exists($NewTableName) && is_file($NewTableName)))
			{
				return false;
			}
			else
			{
				//检测文件是否被锁定
				while(TextDB_isLockTable($TempTableName))
				{
					usleep(50);
				}

				//锁定文件
				TextDB_LockTable($TempTableName);

				//复制数据表
				copy($TableName,$NewTableName);

				$tblinfo = TextDB_SearchData(_TextDB_SysTBL_TableList_,"表名",$TempTableName);
				TextDB_InsertData(_TextDB_SysTBL_TableList_,_TextDB_SysTBLF_TableList_,explode(",",$TempNewTableName.",".$tblinfo[0][2].",".$tblinfo[0][3].",".$tblinfo[0][4].",".$tblinfo[0][5]));

				//释放文件
				TextDB_UnlockTable($TempTableName);

				return true;
			}
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}

//清空数据表
//------------------------------
//$TableName  数据表名称
//------------------------------
function TextDB_CleanTable($TableName)
{
	//检测数据表名称是否符合要求
	if(TextDB_CheckStr($TableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}
	if($GLOBALS["TextDB_Init"])
	{
		if(isset($GLOBALS["TextDB_Link_DB"]))
		{
			$TempTableName = $TableName;
			$TableName     = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_TBL_;
			$LockFile      = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Lock_._TextDB_TBL_;

			if(!file_exists($TableName) and !is_file($TableName))
			{
				return false;
			}
			else
			{
				//检测文件是否被锁定
				while(TextDB_isLockTable($TempTableName))
				{
					usleep(50);
				}

				//锁定文件
				TextDB_LockTable($TempTableName);

				//分析数据表结构
				$Fields    = explode(_TextDB_EXStr_,TextDB_ReadOneLine($TableName));

				//消除换行符号
				$Fields[sizeof($Fields)-1] = "";

				$NewFields = implode(_TextDB_EXStr_,$Fields);

				//清空数据
				TextDB_FileWrite($TableName,"w",$NewFields);

				//更新自增涨字段
				_TextDB_UpdateTableTrueNum($TempTableName,0);

				//释放文件
				TextDB_UnlockTable($TempTableName);

				return true;
			}
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}

//获取 表 安全信息(外部调用)
function TextDB_GetHeaderInfo($TableName)
{
	//检测文件是否被锁定
	while(TextDB_isLockTable($TableName))
	{
		usleep(50);
	}

	//锁定文件
	TextDB_LockTable($TableName);

	$result = _TextDB_GetHeaderInfo($TableName);

	//释放文件
	TextDB_UnlockTable($TableName);

	return $result;
}


//获取 表 安全信息(内部调用)
function _TextDB_GetHeaderInfo($TableName)
{
	//检测数据表名称是否符合要求
	if(TextDB_CheckStr($TableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}

	if($GLOBALS["TextDB_Init"])
	{
		if(isset($GLOBALS["TextDB_Link_DB"]))
		{
			$TempTableName = $TableName;
			$TableName     = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_TBL_;
			$BakTableName  = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Bak_._TextDB_TBL_;
			$LockFile      = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Lock_._TextDB_TBL_;

			if(!file_exists($TableName) and !is_file($TableName))
			{
				if(file_exists($BakTableName) and is_file($BakTableName))
				{
					$TableName = $BakTableName;
				}
				else
				{
					return false;
				}
			}

			//获取数据表信息
			$TableInfo = TextDB_ReadOneLine($TableName);

			//分析数据表安全信息
			$HeaderInfo = explode(_TextDB_EXStr_,$TableInfo);

			return $HeaderInfo[0];
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}

//获取 表 字段（结构）(外部调用)
function TextDB_GetFields($TableName)
{
	//检测文件是否被锁定
	while(TextDB_isLockTable($TableName))
	{
		usleep(50);
	}

	//锁定文件
	TextDB_LockTable($TableName);

	$result = _TextDB_GetFields($TableName);

	//释放文件
	TextDB_UnlockTable($TableName);

	return $result;
}

//获取 表 字段（结构）(内部调用)
function _TextDB_GetFields($TableName)
{
	//检测数据表名称是否符合要求
	if(TextDB_CheckStr($TableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}

	if($GLOBALS["TextDB_Init"])
	{
		if(isset($GLOBALS["TextDB_Link_DB"]))
		{

			$TempTableName = $TableName;
			$TableName     = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_TBL_;
			$BakTableName  = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Bak_._TextDB_TBL_;
			$LockFile      = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Lock_._TextDB_TBL_;

			if(!file_exists($TableName) and !is_file($TableName))
			{
				if(file_exists($BakTableName) and is_file($BakTableName))
				{
					$TableName = $BakTableName;
				}
				else
				{
					return false;
				}
			}

			//获取数据表信息
			$TableInfo = TextDB_ReadOneLine($TableName);

			//分析数据表结构
			$Fields = explode(_TextDB_EXStr_,$TableInfo);

			//整理表字段
			$NewFields = array();
			foreach($Fields as $FieldsID=>$FieldsName)
			{
				if($FieldsID==0 || $FieldsName==='')
				{
					continue;
				}
				$NewFields[$FieldsID-1] = TextDB_FilterStr($FieldsName,0);
			}

			//返回整理字段
			return $NewFields;
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}

//更新表结构（外部调用）
function TextDB_UpdateFields($TableName,$Fields)
{
	//检测文件是否被锁定
	while(TextDB_isLockTable($TableName))
	{
		usleep(50);
	}

	//锁定文件
	TextDB_LockTable($TableName);

	$result = _TextDB_UpdateFields($TableName,$Fields);

	//释放文件
	TextDB_UnlockTable($TableName);

	return $result;
}

//更新表结构（内部调用）
function _TextDB_UpdateFields($TableName,$Fields)
{
	//检测数据表名称是否符合要求
	if(TextDB_CheckStr($TableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}
	$Fields = TextDB_FilterStr($Fields);

	$TempTableName = $TableName;
	$TableName     = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_TBL_;
	$LockFile      = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Lock_._TextDB_TBL_;

	//检测 是否为系统表
	if(TextDB_CheckStr($TempTableName,_TextDB_SysTBSN_,1))
	{
		return false;
	}

	if(!file_exists($TableName) && !is_file($TableName))
	{
		return false;
	}

	//获取字段
	if(!is_array($Fields))
	{
		$Fields = explode(",",$Fields);
	}

	$Fields = TextDB_GetHeaderInfo($TempTableName)._TextDB_EXStr_.implode(_TextDB_EXStr_,$Fields)._TextDB_EXStr_."\n";

	//修改字段
	$tblinfo=TextDB_FileToArray($TableName);
	$tblinfo[0]=$Fields;
	$WriteContent=implode("",$tblinfo);
	TextDB_FileWrite($TableName,"w",$WriteContent);

	return true;
}

//获取表计数（外部调用）
function TextDB_GetTableTrueNum($TableName)
{
	//检测文件是否被锁定
	while(TextDB_isLockTable($TableName))
	{
		usleep(50);
	}

	//锁定文件
	TextDB_LockTable($TableName);

	$result = _TextDB_GetTableTrueNum($TableName);

	//释放文件
	TextDB_UnlockTable($TableName);

	return $result;
}

//2007-11-15
//获取表计数（内部调用）
function _TextDB_GetTableTrueNum($TableName)
{
	//检测数据表名称是否符合要求
	if(TextDB_CheckStr($TableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}

	$TempTableName = $TableName;
	$TableName     = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_TBL_;

	//检测 是否为系统表
	if(TextDB_CheckStr($TempTableName,_TextDB_SysTBSN_,1))
	{
		return false;
	}

	if(!file_exists($TableName) && !is_file($TableName))
	{
		return false;
	}

	$TableInfo = TextDB_SearchData(_TextDB_SysTBL_TableList_,"表名",$TempTableName);

	return $TableInfo[0]["计数"];
}

//更新表计数（外部调用）
function TextDB_UpdateTableTrueNum($TableName,$Mode=1)
{
	//检测文件是否被锁定
	while(TextDB_isLockTable($TableName))
	{
		usleep(50);
	}

	//锁定文件
	TextDB_LockTable($TableName);

	$result = _TextDB_UpdateTableTrueNum($TableName,$Mode);

	//释放文件
	TextDB_UnlockTable($TableName);
}

//2007-11-15
//更新表计数(内部调用)
function _TextDB_UpdateTableTrueNum($TableName,$Mode=1)
{
	//检测数据表名称是否符合要求
	if(TextDB_CheckStr($TableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}

	$TempTableName = $TableName;
	$TableName     = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_TBL_;

	//检测 是否为系统表
	if(TextDB_CheckStr($TempTableName,_TextDB_SysTBSN_,1))
	{
		return false;
	}

	if(!file_exists($TableName) && !is_file($TableName))
	{
		return false;
	}

	$TableInfo = TextDB_SearchData(_TextDB_SysTBL_TableList_,"表名",$TempTableName);

	if($Mode)
	{  //如果为更新模式
		TextDB_ChangeData(_TextDB_SysTBL_TableList_,"表名",$TempTableName,"计数",$TableInfo[0]["计数"]+1);
	}
	else
	{  //如果为重置模式
		TextDB_ChangeData(_TextDB_SysTBL_TableList_,"表名",$TempTableName,"计数",0);
	}

	return $TableInfo[0]["计数"]+1;
}

//插入字段
//-------------------------------------
//$TableName    要插入字段的表名
//$FieldsName   插入字段名称
//$FieldsSN     插入字段位置，可以用名称
//$FieldsPos    插入字段的前后
//$FieldsAll    是否更新所有的内容
//-------------------------------------
function TextDB_InsertFields($TableName,$FieldsName,$FieldsSN=0,$FieldsPos=1,$FieldsAll=1)
{
	//检测数据表名称是否符合要求
	if(TextDB_CheckStr($TableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}

	$FieldsName = TextDB_FilterStr($FieldsName);
	$FieldsSN   = TextDB_FilterStr($FieldsSN);
	if($GLOBALS["TextDB_Init"])
	{
		if(isset($GLOBALS["TextDB_Link_DB"]))
		{
			//获取 数据表 名称和所属库
			$TempTableName = $TableName;
			$TableName     = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_TBL_;
			$LockFile      = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Lock_._TextDB_TBL_;

			//查找 数据表 是否存在
			if(file_exists($TableName) && is_file($TableName))
			{
				//检测文件是否被锁定
				while(TextDB_isLockTable($TempTableName))
				{
					usleep(50);
				}

				//锁定文件
				TextDB_LockTable($TempTableName);

				$DBContent     = TextDB_FileToArray($TableName);
				$DBContentSize = sizeof($DBContent)-1;
				$DBFields      = explode(_TextDB_EXStr_,$DBContent[0]);
				$DBFieldSize   = sizeof($DBFields)-1;

				//获取是否按字段名称插入
				for($i=1;$i<=$DBFieldSize;$i++)
				{
					if($DBFields[$i]==$FieldsSN and !is_int($FieldsSN))
					{
						$FieldsSN = $i;
					}
				}

				//检测是否为已有字段
				for($i=1;$i<=$DBFieldSize;$i++)
				{
					if($DBFields[$i]==$FieldsName)
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}
				}

				//判断是否在结尾插入
				if($FieldsSN!=0)
				{
					if(is_int($FieldsSN))
					{
						//序号超出范围
						if($FieldsSN>$DBFieldSize)
						{
							//释放文件
							TextDB_UnlockTable($TempTableName);
							return false;
						}

						//序号等于最大值在结尾插入
						if($FieldsSN==$DBFieldSize)
						{
							//释放文件
							TextDB_UnlockTable($TempTableName);

							//插入最后
							TextDB_InsertFields($TempTableName,$FieldsName,0,$FieldsPos,$FieldsAll);
						}
						//判断是否数据也同步更新
						if($FieldsAll)
						{
							//判断插入在前还是后
							if(!$FieldsPos)
							{
								$TempFields[0]="";
								$j=0;

								//保留序号以后所有字段
								for($i=$FieldsSN;$i<=$DBFieldSize;$i++)
								{
									$j+=1;
									$TempFields[$j]=$DBFields[$i];
								}

								//替换序号字段
								$DBFields[$FieldsSN]=$FieldsName;

								//重新写入序号字段
								for($i=1;$i<sizeof($TempFields);$i++)
								{
									$DBFields[$FieldsSN+$i]=$TempFields[$i];
								}

								//汇合字段
								$DBContent[0]=implode(_TextDB_EXStr_,$DBFields);

								//同步处理数据
								for($i=1;$i<=$DBContentSize;$i++)
								{
									$DBData      = explode(_TextDB_EXStr_,$DBContent[$i]);
									$DBDataSize  = sizeof($DBData)-1;
									$TempData[0] = "";
									$k           = 0;

									for($j=$FieldsSN;$j<=$DBDataSize;$j++)
									{
										$k+=1;
										$TempData[$k]=$DBData[$j];
									}

									$DBData[$FieldsSN]="";

									for($j=1;$j<sizeof($TempData);$j++)
									{
										$DBData[$FieldsSN+$j]=$TempData[$j];
									}

									$DBContent[$i]=implode(_TextDB_EXStr_,$DBData);
								}
							}
							else
							{
								//序号加1模拟在后面加入
								$FieldsSN+=1;
								$TempFields[0]="";
								$j=0;
								for($i=$FieldsSN;$i<=$DBFieldSize;$i++)
								{
									$j+=1;
									$TempFields[$j]=$DBFields[$i];
								}

								$DBFields[$FieldsSN]=$FieldsName;

								for($i=1;$i<sizeof($TempFields);$i++)
								{
									$DBFields[$FieldsSN+$i]=$TempFields[$i];
								}

								$DBContent[0]=implode(_TextDB_EXStr_,$DBFields);

								for($i=1;$i<=$DBContentSize;$i++)
								{
									$DBData=explode(_TextDB_EXStr_,$DBContent[$i]);
									$DBDataSize=sizeof($DBData)-1;
									$TempData[0]="";
									$k=0;

									for($j=$FieldsSN;$j<=$DBDataSize;$j++)
									{
										$k+=1;
										$TempData[$k]=$DBData[$j];
									}

									$DBData[$FieldsSN]="";

									for($j=1;$j<sizeof($TempData);$j++)
									{
										$DBData[$FieldsSN+$j]=$TempData[$j];
									}

									$DBContent[$i]=implode(_TextDB_EXStr_,$DBData);
								}
							}
						}
						else
						{
							//不同步更新数据模式
							if(!$FieldsPos)
							{
								$TempFields[0]="";
								$j=0;

								for($i=$FieldsSN;$i<=$DBFieldSize;$i++)
								{
									$j+=1;
									$TempFields[$j]=$DBFields[$i];
								}

								$DBFields[$FieldsSN]=$FieldsName;

								for($i=1;$i<sizeof($TempFields);$i++)
								{
									$DBFields[$FieldsSN+$i]=$TempFields[$i];
								}

								$DBContent[0]=implode(_TextDB_EXStr_,$DBFields);
							}
							else
							{
								$FieldsSN+=1;
								$TempFields[0]="";
								$j=0;

								for($i=$FieldsSN;$i<=$DBFieldSize;$i++)
								{
									$j+=1;
									$TempFields[$j]=$DBFields[$i];
								}

								$DBFields[$FieldsSN]=$FieldsName;

								for($i=1;$i<sizeof($TempFields);$i++)
								{
									$DBFields[$FieldsSN+$i]=$TempFields[$i];
								}

								$DBContent[0]=implode(_TextDB_EXStr_,$DBFields);
							}
						}
					}
				}
				else
				{
					//在结尾插入字段
					if($FieldsAll)
					{
						if(!$FieldsPos)
						{
							//在结尾字段前插入
							//增加字段，内容为最后的字段
							$DBFields[$DBFieldSize+1] = $DBFields[$DBFieldSize];

							//修改最后字段，为最后第2个字段
							$DBFields[$DBFieldSize] = $DBFields[$DBFieldSize-1];

							//修改最后第2个字段为，插入字段
							$DBFields[$DBFieldSize-1] = $FieldsName;

							//汇合字段
							$DBContent[0] = implode(_TextDB_EXStr_,$DBFields);

							//同步更新数据
							for($i=1;$i<=$DBContentSize;$i++)
							{
								$DBData                = explode(_TextDB_EXStr_,$DBContent[$i]);
								$DBDataSize            = sizeof($DBData)-1;
								$DBData[$DBDataSize+1] = $DBData[$DBDataSize];
								$DBData[$DBDataSize]   = $DBData[$DBDataSize-1];
								$DBData[$DBDataSize-1] = "";
								$DBContent[$i]         = implode(_TextDB_EXStr_,$DBData);
							}
						}
						else
						{
							//在结尾后插入字段
							//增加字段，内容为最后的字段
							$DBFields[$DBFieldSize+1] = $DBFields[$DBFieldSize];

							//修改最后字段，为插入字段
							$DBFields[$DBFieldSize] = $FieldsName;

							//汇合字段
							$DBContent[0] = implode(_TextDB_EXStr_,$DBFields);

							//同步更新数据
							for($i=1;$i<=$DBContentSize;$i++)
							{
								$DBData                = explode(_TextDB_EXStr_,$DBContent[$i]);
								$DBDataSize            = sizeof($DBData)-1;
								$DBData[$DBDataSize+1] = $DBData[$DBDataSize];
								$DBData[$DBDataSize]   = "";
								$DBContent[$i]         = implode(_TextDB_EXStr_,$DBData);
							}
						}
					}
					else
					{
						//不同步更新数据
						if(!$FieldsPos)
						{
							$DBFields[$DBFieldSize+1] = $DBFields[$DBFieldSize];
							$DBFields[$DBFieldSize]   = $DBFields[$DBFieldSize-1];
							$DBFields[$DBFieldSize-1] = $FieldsName;
							$DBContent[0]             = implode(_TextDB_EXStr_,$DBFields);
						}
						else
						{
							$DBFields[$DBFieldSize+1] = $DBFields[$DBFieldSize];
							$DBFields[$DBFieldSize]   = $FieldsName;
							$DBContent[0]             = implode(_TextDB_EXStr_,$DBFields);
						}
					}
				}

				//汇合所有数据
				$WriteContent = implode("",$DBContent);

				//写入数据
				TextDB_FileWrite($TableName,"w",$WriteContent);

				//释放文件
				TextDB_UnlockTable($TempTableName);

				return true;
			}
			else
			{
				return false;
			}
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}

//删除字段
//------------------------------------------
//$TableName    要删除字段的表名
//$FieldsSN     删除字段序号(名称)，可以是数组
//$FieldsAll    是否更新所有的内容
//------------------------------------------
function TextDB_DeleteFields($TableName,$FieldsSN,$FieldsAll=1)
{
	//检测数据表名称是否符合要求
	if(TextDB_CheckStr($TableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}

	$FieldsSN = TextDB_FilterStr($FieldsSN);
	if($GLOBALS["TextDB_Init"])
	{
		if(isset($GLOBALS["TextDB_Link_DB"]))
		{
			//获取 数据表 名称和所属库
			$TempTableName = $TableName;
			$TableName     = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_TBL_;
			$LockFile      = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Lock_._TextDB_TBL_;

			//查找 数据表 是否存在
			if(file_exists($TableName) && is_file($TableName))
			{
				//检测文件是否被锁定
				while(TextDB_isLockTable($TempTableName))
				{
					usleep(50);
				}

				//锁定文件
				TextDB_LockTable($TempTableName);

				$DBContent     = TextDB_FileToArray($TableName);
				$DBContentSize = sizeof($DBContent)-1;
				$DBFields      = explode(_TextDB_EXStr_,$DBContent[0]);
				$DBFieldSize   = sizeof($DBFields)-1;

				//获取是否按字段名称插入
				if(is_array($FieldsSN))
				{
					for($i=0;$i<sizeof($FieldsSN);$i++)
					{
						for($j=1;$j<=$DBFieldSize;$j++)
						{
							if($DBFields[$j]==TextDB_FilterStr($FieldsSN[$i]))
							{
								$FieldsSN[$i]=$j;
							}
						}
						if(!is_int($FieldsSN[$i]))
						{
							//释放文件
							TextDB_UnlockTable($TempTableName);
							return false;
						}
					}
				}
				else
				{
					for($i=1;$i<=$DBFieldSize;$i++)
					{
						if($DBFields[$i]==TextDB_FilterStr($FieldsSN))
						{
							$FieldsSN=$i;
						}
					}
					if(!is_int($FieldsSN))
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}
				}

				//删除字段
				if(is_array($FieldsSN))
				{
					//删除多个字段
					if($FieldsAll)
					{
						//连同数据一起删除下
						//删除字段内容
						for($i=0;$i<sizeof($FieldsSN);$i++)
						{
							$DBFields[$FieldsSN[$i]]="";
						}

						//合并字段内容
						$j=0;
						for($i=0;$i<=$DBFieldSize;$i++)
						{
							//检测是否以被删除
							if(!empty($DBFields[$i]) or $i==0 or $i==$DBFieldSize)
							{
								$TempFields[$j]=$DBFields[$i];
								$j+=1;
							}
						}
						$DBFields=$TempFields;

						//汇合字段
						$DBContent[0]=implode(_TextDB_EXStr_,$DBFields);

						//卸载已汇合字段信息
						unset($DBFields,$TempFields);

						//汇合数据
						for($i=1;$i<=$DBContentSize;$i++)
						{
							if(!empty($DBContent[$i])){
								$DBData     = explode(_TextDB_EXStr_,$DBContent[$i]);
								$DBDataSize = sizeof($DBData)-1;

								//删除数据
								for($j=0;$j<sizeof($FieldsSN);$j++)
								{
									$DBData[$FieldsSN[$j]]="";
								}

								//合并数据内容
								$k = 0;
								for($j=0;$j<=$DBDataSize;$j++)
								{
									if(!empty($DBData[$j]) || $j==0 || $j==$DBDataSize)
									{
										$TempData[$k]=$DBData[$j];
										$k+=1;
									}
								}
								$DBData=$TempData;

								//汇合数据
								$DBContent[$i]=implode(_TextDB_EXStr_,$DBData);

								//*****卸载已汇合数据，防止出现异常****
								unset($DBData,$TempData);
							}
						}
					}
					else
					{
						//不删除数据
						//删除字段
						for($i=0;$i<sizeof($FieldsSN);$i++)
						{
							$DBFields[$FieldsSN[$i]]="";
						}

						//合并字段
						$j=0;
						for($i=0;$i<=$DBFieldSize;$i++)
						{
							//检测是否已删除
							if(!empty($DBFields[$i]) or $i==0 or $i==$DBFieldSize)
							{
								$TempFields[$j]=$DBFields[$i];
								$j+=1;
							}
						}
						$DBFields=$TempFields;

						//汇合字段
						$DBContent[0]=implode(_TextDB_EXStr_,$DBFields);

						//删除汇合字段信息
						unset($DBFields,$TempFields);
					}
				}
				else
				{
					//删除单个字段
					if($FieldsAll)
					{
						//连同数据删除模式
						//删除字段
						$DBFields[$FieldsSN]="";

						//合并字段
						$j=0;
						for($i=0;$i<=$DBFieldSize;$i++)
						{
							//检测是否已删除
							if(!empty($DBFields[$i]) || $i==0 || $i==$DBFieldSize)
							{
								$TempFields[$j]=$DBFields[$i];
								$j+=1;
							}
						}
						$DBFields=$TempFields;

						//汇合字段
						$DBContent[0]=implode(_TextDB_EXStr_,$DBFields);

						//删除汇合字段信息
						unset($DBFields,$TempFields);

						//删除数据
						for($i=1;$i<=$DBContentSize;$i++)
						{
							$DBData=explode(_TextDB_EXStr_,$DBContent[$i]);
							$DBDataSize=sizeof($DBData)-1;
							//删除数据
							$DBData[$FieldsSN]="";

							//合并数据
							$k=0;
							for($j=0;$j<=$DBDataSize;$j++)
							{
								//检测是否已删除
								if(!empty($DBData[$j]) or $j==0 or $j==$DBDataSize)
								{
									$TempData[$k]=$DBData[$j];
									$k+=1;
								}
							}
							$DBData=$TempData;

							//汇合数据
							$DBContent[$i]=implode(_TextDB_EXStr_,$DBData);

							//*****卸载已汇合数据，防止出现异常****
							unset($DBData,$TempData);
						}
					}
					else
					{
						//不删除数据
						//删除字段
						$DBFields[$FieldsSN]="";

						//合并字段
						$j=0;
						for($i=0;$i<=sizeof($DBFields);$i++)
						{
							//检测是否已删除
							if(!empty($DBFields[$i]) or $i==0 or $i==$DBFieldSize)
							{
								$TempFields[$j]=$DBFields[$i];
								$j+=1;
							}
						}
						$DBFields=$TempFields;

						//汇合字段
						$DBContent[0]=implode(_TextDB_EXStr_,$DBFields);

						//删除汇合字段信息
						unset($DBFields,$TempFields);
					}
				}

				//汇合所有数据
				$WriteContent = implode("",$DBContent);
				//写入数据
				TextDB_FileWrite($TableName,"w",$WriteContent);

				//释放文件
				TextDB_UnlockTable($TempTableName);

				return true;
			}
			else
			{
				return false;
			}
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}

//修改字段
//------------------------------------------
//$TableName    要修改字段的表名
//$FieldsSN     被替换字段名称
//$FieldsName   替换的字段名称
//------------------------------------------
function TextDB_ChangeFields($TableName,$FieldsSN,$FieldsName)
{
	if($GLOBALS["TextDB_Init"])
	{
		if(isset($GLOBALS["TextDB_Link_DB"]))
		{
			//获取 数据表 名称和所属库
			$TempTableName = $TableName;
			$TableName     = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_TBL_;
			$LockFile      = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Lock_._TextDB_TBL_;

			//查找 数据表 是否存在
			if(file_exists($TableName) and is_file($TableName))
			{
				//检测文件是否被锁定
				while(TextDB_isLockTable($TempTableName))
				{
					usleep(50);
				}

				//锁定文件
				TextDB_LockTable($TempTableName);

				$DBContent   = TextDB_FileToArray($TableName);
				$DBFields    = explode(_TextDB_EXStr_,$DBContent[0]);
				$DBFieldSize = sizeof($DBFields)-1;

				//检测是否提交完善的修改数据
				if(empty($FieldsSN) or empty($FieldsName))
				{
					//释放文件
					TextDB_UnlockTable($TempTableName);
					return false;
				}

				//获取是否按字段名称修改
				if(is_array($FieldsSN))
				{
					for($i=0;$i<sizeof($FieldsSN);$i++)
					{
						for($j=1;$j<=$DBFieldSize;$j++)
						{
							if($DBFields[$j]==TextDB_FilterStr($FieldsSN[$i]))
							{
								$FieldsSN[$i]=$j;
							}
						}
						//如果不存在字段，返回
						if(!is_int($FieldsSN[$i]))
						{
							//释放文件
							TextDB_UnlockTable($TempTableName);
							return false;
						}
					}
				}
				else
				{
					for($i=1;$i<=$DBFieldSize;$i++)
					{
						if($DBFields[$i]==TextDB_FilterStr($FieldsSN))
						{
							$FieldsSN=$i;
						}
					}
					//如果不存在字段，返回
					if(!is_int($FieldsSN))
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}
				}

				//修改字段
				if(is_array($FieldsSN))
				{
					for($i=0;$i<=sizeof($FieldsSN);$i++)
					{
						$DBFields[$FieldsSN[$i]]=TextDB_FilterStr($FieldsName[$i]);
					}
				}
				else
				{
					$DBFields[$FieldsSN]=TextDB_FilterStr($FieldsName);
				}

				//汇合字段
				$DBContent[0]=implode(_TextDB_EXStr_,$DBFields);

				//删除汇合字段信息
				unset($DBFields);

				//汇合所有数据
				$WriteContent=implode("",$DBContent);

				//写入数据
				TextDB_FileWrite($TableName,"w",$WriteContent);

				//释放文件
				TextDB_UnlockTable($TempTableName);

				return true;
			}
			else
			{
				return false;
			}
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}

//插入数据
//-------------------------------
//$TableName   数据表名称
//$Fields      欲增添字段名
//$Values      欲增添数据
//-------------------------------
function TextDB_InsertData($TableName,$Fields,$Values)
{
	//检测数据表名称是否符合要求
	if(TextDB_CheckStr($TableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}

	if($GLOBALS["TextDB_Init"])
	{
		if(isset($GLOBALS["TextDB_Link_DB"]))
		{
			//获取 数据表 名称和所属库
			$TempTableName = $TableName;
			$TableName     = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_TBL_;
			$LockFile      = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Lock_._TextDB_TBL_;

			//查找 数据表 是否存在
			if(file_exists($TableName) && is_file($TableName))
			{
				//检测文件是否被锁定
				while(TextDB_isLockTable($TempTableName))
				{
					usleep(50);
				}

				//锁定文件
				TextDB_LockTable($TempTableName);

				$TableFields     = explode(_TextDB_EXStr_,TextDB_ReadOneLine($TableName));
				$TableFieldsSize = sizeof($TableFields);

				//初始化数据列表
				//检测 是否为系统表
				if(TextDB_CheckStr($TempTableName,_TextDB_SysTBSN_,1))
				{
					$data[0] = "\n";
				}
				else
				{
					$data[0] = "\n"._TextDB_UpdateTableTrueNum($TempTableName);
				}

				for($i = 1; $i < $TableFieldsSize; $i++)
				{
					$data[$i] = "";
				}

				//2007-10-25
				//如果字段为 * 默认获取全部字段
				if($Fields == "*")
				{
					$Fields = _TextDB_GetFields($TempTableName);
					$Fields = implode(",",$Fields);
				}

				if(strstr($Fields,","))
				{
					$Fields = explode(",",$Fields);
				}

				//模拟字段数组
				if(is_array($Fields))
				{
					//多个字段添加
					//检测字段和数据数据类型是否对应
					if(!is_array($Values))
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//获取字段个数，欲填字段
					$FieldsSize = sizeof($Fields)-1;

					//获取数据个数，欲填数据
					$ValuesSize = sizeof($Values)-1;

					//检测字段，数据是否对应
					if($FieldsSize != $ValuesSize)
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//检测字段是否对应
					if($FieldsSize < $TableFieldsSize or $Fields == 0)
					{
						//获取字段ID
						for($i = 0; $i <= $FieldsSize; $i++)
						{
							for($j = 1; $j < $TableFieldsSize; $j++)
							{
								//如果字段存在，赋予ID
								if(TextDB_FilterStr($Fields[$i]) == $TableFields[$j])
								{
									$Fields[$i] = $j;
								}
							}

							//如果字段不为ID，就表明字段不存在，返回错误
							if(!is_int($Fields[$i]))
							{
								//释放文件
								TextDB_UnlockTable($TempTableName);
								return false;
							}
						}
					}
					else
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//串联数据
					for($i = 0; $i <= $FieldsSize; $i++)
					{
						$data[$Fields[$i]] = TextDB_FilterStr($Values[$i]);
					}
				}
				else
				{
					//非多个字段添加
					//检测字段和数据数据类型是否对应
					if(is_array($Values))
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					for($i = 1;$i < $TableFieldsSize; $i++)
					{
						//如果字段存在，赋予ID
						if(TextDB_FilterStr($Fields) == $TableFields[$i])
						{
							$Fields = $i;
						}
					}

					//如果字段不为ID，就表明字段不存在，返回错误
					if(!is_int($Fields))
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//串联数据
					$data[$Fields] = TextDB_FilterStr($Values);
				}

				//组合数据
				$WriteContent = implode(_TextDB_EXStr_,$data);
				//写入数据
				TextDB_FileWrite($TableName,"a",$WriteContent);

				//释放文件
				TextDB_UnlockTable($TempTableName);

				return true;

			}
			else
			{
				return false;
			}
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}

//删除数据
//-------------------------------
//$TableName      数据表名
//$Fields         字段名
//$Values         数值名
//-------------------------------
function TextDB_DeleteData($TableName,$Fields,$Values)
{
	//检测数据表名称是否符合要求
	if(TextDB_CheckStr($TableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}

	if($GLOBALS["TextDB_Init"])
	{
		if(isset($GLOBALS["TextDB_Link_DB"]))
		{
			//获取 数据表 名称和所属库
			$TempTableName = $TableName;
			$TableName     = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_TBL_;
			$LockFile      = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Lock_._TextDB_TBL_;

			//查找 数据表 是否存在
			if(file_exists($TableName) && is_file($TableName))
			{
				//检测文件是否被锁定
				while(TextDB_isLockTable($TempTableName))
				{
					usleep(50);
				}

				//锁定文件
				TextDB_LockTable($TempTableName);

				$TableContent     = TextDB_FileToArray($TableName);
				$TableContentSize = sizeof($TableContent)-1;;
				$TableFields      = explode(_TextDB_EXStr_,TextDB_ReadOneLine($TableName));
				$TableFieldsSize  = sizeof($TableFields);

				//2007-10-30
				//如果字段为 * 默认获取全部字段
				if($Fields == "*")
				{
					$Fields = _TextDB_GetFields($TempTableName);
					$Fields = implode(",",$Fields);
				}

				if(strstr($Fields,","))
				{
					$Fields = explode(",",$Fields);
				}

				//模拟字段数组
				if(is_array($Fields))
				{
					//多个字段添加
					//检测字段和数据数据类型是否对应
					if(!is_array($Values))
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//获取字段个数，欲填字段
					$FieldsSize = sizeof($Fields)-1;

					//获取数据个数，欲填数据
					$ValuesSize = sizeof($Values)-1;

					//检测字段，数据是否对应
					if($FieldsSize != $ValuesSize)
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//检测字段是否对应
					if($FieldsSize < $TableFieldsSize or $Fields == 0)
					{
						//获取字段ID
						for($i = 0; $i <= $FieldsSize; $i++)
						{
							if($Fields[$i] != "TEXTDB_HID")
							{
								for($j = 1; $j < $TableFieldsSize; $j++)
								{
									//如果字段存在，赋予ID
									if(TextDB_FilterStr($Fields[$i]) == $TableFields[$j])
									{
										$Fields[$i] = $j;
									}
								}
							}
							else
							{
								$Fields[$i] = 0;
							}

							//如果字段不为ID，就表明字段不存在，返回错误
							if(!is_int($Fields[$i]))
							{
								//释放文件
								TextDB_UnlockTable($TempTableName);
								return false;
							}
						}
					}
					else
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//查找数据并清除
					$IN = 0;
					for($i = 1; $i <= $TableContentSize; $i++)
					{
						$k = 0;
						$TableData = explode(_TextDB_EXStr_,$TableContent[$i]);

						//检测是否有符合多条件数据
						for($j = 0; $j <= $FieldsSize; $j++)
						{
							if($TableData[$Fields[$j]] == TextDB_FilterStr($Values[$j]))
							{
								$k+=1;
							}
						}

						//测试数据-1，同等sizeof($Fields)-1
						if($k-1 == $FieldsSize)
						{
							$TableContent[$i] = "D";
							$IN = 1;
						}
					}
				}
				else
				{
					//非多个字段添加
					//检测字段和数据数据类型是否对应
					if(is_array($Values))
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					if($Fields != "TEXTDB_HID")
					{
						for($i = 1; $i < $TableFieldsSize; $i++)
						{
							//如果字段存在，赋予ID
							if(TextDB_FilterStr($Fields) == $TableFields[$i])
							{
								$Fields = $i;
							}
						}
					}
					else
					{
						$Fields = 0;
					}

					//如果字段不为ID，就表明字段不存在，返回错误
					if(!is_int($Fields))
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//查找数据并清除
					$IN = 0;
					for($i = 1; $i <= $TableContentSize; $i++)
					{
						$TableData = explode(_TextDB_EXStr_,$TableContent[$i]);
						if($TableData[$Fields] == TextDB_FilterStr($Values))
						{
							$TableContent[$i] = "D";
							$IN = 1;
						}
					}
				}
				//检测是否有可删除数据
				if(!$IN)
				{
					//释放文件
					TextDB_UnlockTable($TempTableName);
					return false;
				}

				//合并新数据
				$NewTableContent[0] = $TableContent[0];
				$j = 0;
				for($i = 1; $i <= $TableContentSize; $i++)
				{
					if($TableContent[$i] != "D"){
						$j+=1;
						$NewTableContent[$j] = $TableContent[$i];
					}
				}

				//分析最后的数据
				$LastData = explode(_TextDB_EXStr_,$NewTableContent[sizeof($NewTableContent)-1]);

				//消除换行符号
				$LastData[sizeof($LastData)-1] = "";

				//合并最后的数据
				$NewTableContent[sizeof($NewTableContent)-1] = implode(_TextDB_EXStr_,$LastData);

				$WriteContent = implode("",$NewTableContent);

				//写入数据
				TextDB_FileWrite($TableName,"w",$WriteContent);

				//释放文件
				TextDB_UnlockTable($TempTableName);

				return true;
			}
			else
			{
				return false;
			}
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}

//更新数据(修改数据别名)
function TextDB_UpdateData($TableName,$SearchFields=0,$SearchValues=null,$Fields=0,$Values=null)
{
	return TextDB_ChangeData($TableName,$SearchFields,$SearchValues,$Fields,$Values);
}

//修改数据
function TextDB_ChangeData($TableName,$SearchFields=0,$SearchValues=null,$Fields=0,$Values=null)
{
	//检测数据表名称是否符合要求
	if(TextDB_CheckStr($TableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}

	if($GLOBALS["TextDB_Init"])
	{
		if(isset($GLOBALS["TextDB_Link_DB"]))
		{
			//获取 数据表 名称和所属库
			$TempTableName = $TableName;
			$TableName     = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_TBL_;
			$LockFile      = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Lock_._TextDB_TBL_;

			//查找 数据表 是否存在
			if(file_exists($TableName) && is_file($TableName))
			{
				//检测文件是否被锁定
				while(TextDB_isLockTable($TempTableName))
				{
					usleep(50);
				}

				//锁定文件
				TextDB_LockTable($TempTableName);

				$TableContent     = TextDB_FileToArray($TableName);
				$TableContentSize = sizeof($TableContent)-1;
				$TableFields      = explode(_TextDB_EXStr_,TextDB_ReadOneLine($TableName));
				$TableFieldsSize  = sizeof($TableFields);

				//2007-10-30
				//如果字段为 * 默认获取全部字段
				if($Fields=="*")
				{
					$Fields = _TextDB_GetFields($TempTableName);
					$Fields = implode(",",$Fields);
				}

				if(strstr($Fields,","))
				{
					$Fields = explode(",",$Fields);
				}

				//模拟字段数组
				if(is_array($SearchFields))
				{
					//多个字段添加
					//检测字段和数据数据类型是否对应
					if(!is_array($SearchValues))
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//获取字段个数，欲填字段
					$SearchFieldsSize = sizeof($SearchFields)-1;

					//获取数据个数，欲填数据
					$SearchValuesSize = sizeof($SearchValues)-1;

					//检测字段，数据是否对应
					if($SearchFieldsSize!=$SearchValuesSize)
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//检测字段是否对应
					if($SearchFieldsSize<$TableFieldsSize or $SearchFields==0)
					{
						//获取字段ID
						for($i=0;$i<=$SearchFieldsSize;$i++)
						{
							if($SearchFields[$i]!="TEXTDB_HID")
							{
								for($j=1;$j<$TableFieldsSize;$j++)
								{
									//如果字段存在，赋予ID
									if(TextDB_FilterStr($SearchFields[$i])==$TableFields[$j])
									{
										$SearchFields[$i]=$j;
									}
								}
							}
							else
							{
								$SearchFields[$i]=0;
							}

							//如果字段不为ID，就表明字段不存在，返回错误
							if(!is_int($SearchFields[$i]))
							{
								//释放文件
								TextDB_UnlockTable($TempTableName);
								return false;
							}
						}
					}
					else
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//查找数据并返回
					$IN=0;
					for($i=1;$i<=$TableContentSize;$i++)
					{
						$k=0;
						$TableData=explode(_TextDB_EXStr_,$TableContent[$i]);

						//检测是否有符合多条件数据
						for($j=0;$j<=$SearchFieldsSize;$j++)
						{
							if($TableData[$SearchFields[$j]]==TextDB_FilterStr($SearchValues[$j]))
							{
								$k+=1;
							}
						}
						//测试数据-1，同等sizeof($Fields)-1
						if($k-1==$SearchFieldsSize)
						{

							//模拟字段数组
							if(is_array($Fields))
							{
								//多个字段添加
								//检测字段和数据数据类型是否对应
								if(!is_array($Values))
								{
									//释放文件
									TextDB_UnlockTable($TempTableName);
									return false;
								}

								//获取字段个数，欲填字段
								$FieldsSize = sizeof($Fields)-1;

								//获取数据个数，欲填数据
								$ValuesSize = sizeof($Values)-1;

								//检测字段，数据是否对应
								if($FieldsSize!=$ValuesSize)
								{
									//释放文件
									TextDB_UnlockTable($TempTableName);
									return false;
								}

								//检测字段是否对应
								if($FieldsSize<$TableFieldsSize or $Fields==0)
								{
									//获取字段ID
									for($j=0;$j<=$FieldsSize;$j++)
									{
										if($Fields[$j]!="TEXTDB_HID")
										{
											for($k=1;$k<$TableFieldsSize;$k++)
											{
												//如果字段存在，赋予ID
												if(TextDB_FilterStr($Fields[$j])==$TableFields[$k])
												{
													$Fields[$j]=$k;
												}
											}
										}
										else
										{
											$Fields[$j]=0;
										}

										//如果字段不为ID，就表明字段不存在，返回错误
										if(!is_int($Fields[$j]))
										{
											//释放文件
											TextDB_UnlockTable($TempTableName);
											return false;
										}
									}
								}
								else
								{
									//释放文件
									TextDB_UnlockTable($TempTableName);
									return false;
								}

								//分析数据
								$TempData = explode(_TextDB_EXStr_,$TableContent[$i]);

								//修改数据
								for($l=0;$l<=$FieldsSize;$l++)
								{
									$TempData[$Fields[$l]] = TextDB_FilterStr($Values[$l]);
								}
								$TableContent[$i] = implode(_TextDB_EXStr_,$TempData);

								unset($TempData);
								$IN=1;

							}
							else
							{
								//非多个字段添加
								//检测字段和数据数据类型是否对应
								if(is_array($Values))
								{
									//释放文件
									TextDB_UnlockTable($TempTableName);
									return false;
								}

								if($Fields!="TEXTDB_HID")
								{
									for($j=1;$j<$TableFieldsSize;$j++)
									{
										//如果字段存在，赋予ID
										if(TextDB_FilterStr($Fields)==$TableFields[$j])
										{
											$Fields=$j;
										}
									}
								}
								else
								{
									$Fields=0;
								}

								//如果字段不为ID，就表明字段不存在，返回错误
								if(!is_int($Fields))
								{
									//释放文件
									TextDB_UnlockTable($TempTableName);
									return false;
								}

								//分析数据
								$TempData = explode(_TextDB_EXStr_,$TableContent[$i]);

								//修改数据
								for($l=0;$l<=$FieldsSize;$l++)
								{
									$TempData[$Fields] = TextDB_FilterStr($Values);
								}
								$TableContent[$i] = implode(_TextDB_EXStr_,$TempData);

								unset($TempData);
								$IN=1;
							}
						}
					}
				}
				else
				{
					//非多个字段添加
					//检测字段和数据数据类型是否对应
					if(is_array($SearchValues))
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					if($SearchFields!="TEXTDB_HID")
					{
						for($i=1;$i<$TableFieldsSize;$i++)
						{
							//如果字段存在，赋予ID
							if(TextDB_FilterStr($SearchFields)==$TableFields[$i])
							{
								$SearchFields = $i;
							}
						}
					}
					else
					{
						$SearchFields = 0;
					}

					//如果字段不为ID，就表明字段不存在，返回错误
					if(!is_int($SearchFields))
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//查找数据并返回
					$IN=0;
					for($i=1;$i<=$TableContentSize;$i++)
					{
						$TableData = explode(_TextDB_EXStr_,$TableContent[$i]);
						if($TableData[$SearchFields]==TextDB_FilterStr($SearchValues))
						{
							//模拟字段数组
							if(is_array($Fields))
							{
								//多个字段添加
								//检测字段和数据数据类型是否对应
								if(!is_array($Values))
								{
									//释放文件
									TextDB_UnlockTable($TempTableName);
									return false;
								}

								//获取字段个数，欲填字段
								$FieldsSize = sizeof($Fields)-1;

								//获取数据个数，欲填数据
								$ValuesSize = sizeof($Values)-1;

								//检测字段，数据是否对应
								if($FieldsSize!=$ValuesSize)
								{
									//释放文件
									TextDB_UnlockTable($TempTableName);
									return false;
								}

								//检测字段是否对应
								if($FieldsSize<$TableFieldsSize or $Fields==0)
								{
									//获取字段ID
									for($j=0;$j<=$FieldsSize;$j++)
									{
										if($Fields[$j]!="TEXTDB_HID")
										{
											for($k=1;$k<$TableFieldsSize;$k++)
											{
												//如果字段存在，赋予ID
												if(TextDB_FilterStr($Fields[$j])==$TableFields[$k])
												{
													$Fields[$j]=$k;
												}
											}
										}
										else
										{
											$Fields[$j]=0;
										}

										//如果字段不为ID，就表明字段不存在，返回错误
										if(!is_int($Fields[$j]))
										{
											//释放文件
											TextDB_UnlockTable($TempTableName);
											return false;
										}
									}
								}
								else
								{
									//释放文件
									TextDB_UnlockTable($TempTableName);
									return false;
								}

								//分析数据
								$TempData = explode(_TextDB_EXStr_,$TableContent[$i]);

								//修改数据
								for($l=0;$l<=$FieldsSize;$l++)
								{
									$TempData[$Fields[$l]] = TextDB_FilterStr($Values[$l]);
								}
								$TableContent[$i] = implode(_TextDB_EXStr_,$TempData);

								unset($TempData);
								$IN=1;

							}
							else
							{
								//非多个字段添加
								//检测字段和数据数据类型是否对应
								if(is_array($Values))
								{
									//释放文件
									TextDB_UnlockTable($TempTableName);
									return false;
								}

								if($Fields!="TEXTDB_HID")
								{
									for($j=1;$j<$TableFieldsSize;$j++)
									{
										//如果字段存在，赋予ID
										if(TextDB_FilterStr($Fields)==$TableFields[$j])
										{
											$Fields=$j;
										}
									}
								}
								else
								{
									$Fields=0;
								}

								//如果字段不为ID，就表明字段不存在，返回错误
								if(!is_int($Fields))
								{
									//释放文件
									TextDB_UnlockTable($TempTableName);
									return false;
								}

								//分析数据
								$TempData = explode(_TextDB_EXStr_,$TableContent[$i]);

								//修改数据
								$TempData[$Fields] = TextDB_FilterStr($Values);

								//合并数
								$TableContent[$i] = implode(_TextDB_EXStr_,$TempData);

								unset($TempData);
								$IN=1;
							}
						}
					}
				}
				//检测是否有修改数据
				if(!$IN)
				{
					//释放文件
					TextDB_UnlockTable($TempTableName);
					return false;
				}

				//分析最后的数据
				$LastData = explode(_TextDB_EXStr_,$TableContent[$TableContentSize]);

				//消除换行符号
				$LastData[sizeof($LastData)-1] = "";

				//合并最后的数据
				$TableContent[$TableContentSize] = implode(_TextDB_EXStr_,$LastData);

				$WriteContent = implode("",$TableContent);

				//写入数据
				TextDB_FileWrite($TableName,"w",$WriteContent);

				//释放文件
				TextDB_UnlockTable($TempTableName);

				return true;
			}
			else
			{
				return false;
			}
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}

//获取已搜索数据行数
// 创建日期 2008-8-29
// 参数说明
//   $Data 搜索返回数据
function TextDB_DataRows($Data)
{
	if(is_array($Data))
	{
		return count($Data);
	}
	else
	{
		return false;
	}
}


//获取数据
// TextDB_SearchData() 别名
function TextDB_GetData($TableName,$Fields=NULL,$Values=NULL,$Order="asc",$OrderFields=NULL,$StartNum=NULL,$Number=NULL)
{
	return TextDB_SearchData($TableName,$Fields,$Values,$Order,$StartNum=NULL,$Number=NULL);
}

//搜索数据
//
// 参数说明
//   $TableName   //搜索表
//   $Fields      //搜索字段
//   $Values      //搜索数值
//   $Order       //排序 顺序（ASC），倒序（DESC）,乱序（RAND）
//   $OrderFields //排序字段
//   $StartNum    //开始行
//   $Number      //获取行数
function TextDB_SearchData($TableName,$Fields=NULL,$Values=NULL,$Order="asc",$OrderFields=NULL,$StartNum=NULL,$Number=NULL)
{
	//检测数据表名称是否符合要求
	if(TextDB_CheckStr($TableName,_TextDB_SysFilter_TBN_))
	{
		return false;
	}
	if($GLOBALS["TextDB_Init"])
	{
		if(isset($GLOBALS["TextDB_Link_DB"]))
		{
			$TempTableName = $TableName;
			$TableName     = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_TBL_;
			$BakTableName  = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Bak_._TextDB_TBL_;
			$LockFile      = _TextDB_SQLPath_."/_".$GLOBALS["TextDB_Link_DB"]."/_".$TempTableName._TextDB_Lock_._TextDB_TBL_;

			//检测表
			if(!file_exists($TableName) and !is_file($TableName))
			{
				if(file_exists($BakTableName) and is_file($BakTableName))
				{
					$TableName = $BakTableName;
				}
				else
				{
					return false;
				}
			}

			//检测文件是否被锁定
			while(TextDB_isLockTable($TempTableName))
			{
				usleep(50);
			}

			//锁定文件
			TextDB_LockTable($TempTableName);

			//分析数据表内容
			$TableContent     = TextDB_FileToArray($TableName);
			$TableContentSize = sizeof($TableContent);

			//分析数据表结构
			$TableFields      = explode(_TextDB_EXStr_,TextDB_ReadOneLine($TableName));
			$TableFieldsSize  = sizeof($TableFields);

			//生成空数据列表
			$DataList = "";

			//获取全部数据
			if(empty($Fields) and empty($Values))  //如果搜索字段和数据为空
			{
				$m  = 0;

				for($i=1;$i<$TableContentSize;$i++)
				{
					$TempData=explode(_TextDB_EXStr_,$TableContent[$i]);

					//获取数据表表字段个数(去处开头结尾)
					$TempDataSize=sizeof($TempData)-1;
					$NewData="";

					//整理表字段
					for($j=0;$j<$TempDataSize;$j++)
					{
						$NewData[$j] = TextDB_FilterStr($TempData[$j],0);
						if($j>0)
						{
							$NewData[TextDB_FilterStr($TableFields[$j],0)] = TextDB_FilterStr($TempData[$j],0);
						}
						else
						{
							$NewData['TEXTDB_HID'] = TextDB_FilterStr($TempData[$j],0);
						}
					}
					$TempDataList[$m] = $NewData;
					unset($TempData,$NewData);
					$m++;
				}
			}
			elseif(isset($Fields) and isset($Values))  //如果搜索字段和数据不为空
			{
				//检测搜索字段是否为多个字段
				if(strstr($Fields,","))
				{
					$Fields = explode(",",$Fields);
				}

				//模拟字段数组
				if(is_array($Fields))
				{
					//多个字段添加
					//检测字段和数据数据类型是否对应
					if(!is_array($Values))
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//获取字段个数，欲填字段
					$FieldsSize = sizeof($Fields)-1;

					//获取数据个数，欲填数据
					$ValuesSize = sizeof($Values)-1;

					//检测字段，数据是否对应
					if($FieldsSize!=$ValuesSize)
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//检测字段是否对应
					if($FieldsSize<$TableFieldsSize or $Fields==0)
					{
						//获取字段ID
						for($i=0;$i<=$FieldsSize;$i++)
						{
							if($Fields[$i]!="TEXTDB_HID")
							{
								for($j=1;$j<$TableFieldsSize;$j++)
								{
									//如果字段存在，赋予ID
									if(TextDB_FilterStr($Fields[$i])==$TableFields[$j])
									{
										$Fields[$i] = $j;
									}
								}
							}
							else
							{
								$Fields[$i] = 0;
							}

							//如果字段不为ID，就表明字段不存在，返回错误
							if(!is_int($Fields[$i]))
							{
								//释放文件
								TextDB_UnlockTable($TempTableName);
								return false;
							}
						}
					}
					else
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//查找数据并返回
					$m  = 0;

					for($i=1;$i<$TableContentSize;$i++)
					{
						//设置字段检测变量
						$k=0;
						$TableData=explode(_TextDB_EXStr_,$TableContent[$i]);
						//检测是否有符合多条件数据
						for($j=0;$j<=$FieldsSize;$j++)
						{
							if($TableData[$Fields[$j]]==TextDB_FilterStr($Values[$j]))
							{
								$k+=1;
							}
						}

						//测试数据-1，同等sizeof($Fields)-1
						if($k-1==$FieldsSize)
						{
							//分析数据表结构
							$TempData = explode(_TextDB_EXStr_,$TableContent[$i]);

							//获取表字段个数
							$TempDataSize = sizeof($TempData)-1;
							$NewData = "";

							//整理表字段
							for($l=0;$l<$TempDataSize;$l++)
							{
								$NewData[$l]=TextDB_FilterStr($TempData[$l],0);
								if($l>0)
								{
									$NewData[TextDB_FilterStr($TableFields[$l],0)] = TextDB_FilterStr($TempData[$l],0);
								}
								else
								{
									$NewData['TEXTDB_HID'] = TextDB_FilterStr($TempData[$l],0);
								}
							}
							$TempDataList[$m] = $NewData;
							unset($TempData,$NewData);
							$m+=1;
						}
					}
				}
				else
				{
					//非多个字段添加
					//检测字段和数据数据类型是否对应
					if(is_array($Values))
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					if($Fields!="TEXTDB_HID")
					{
						for($i=1;$i<$TableFieldsSize;$i++)
						{
							//如果字段存在，赋予ID
							if(TextDB_FilterStr($Fields)==$TableFields[$i])
							{
								$Fields = $i;
							}
						}
					}
					else
					{
						$Fields = 0;
					}

					//如果字段不为ID，就表明字段不存在，返回错误
					if(!is_int($Fields))
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//查找数据并返回
					$k=0;
					for($i=1;$i<$TableContentSize;$i++)
					{
						$TableData=explode(_TextDB_EXStr_,$TableContent[$i]);
						if(isset($TableData[$Fields]) && $TableData[$Fields]==$Values)
						{
							//分析数据表结构
							$TempData = explode(_TextDB_EXStr_,$TableContent[$i]);

							//获取表字段个数
							$TempDataSize = sizeof($TempData)-1;
							$NewData      = "";

							//整理表字段
							for($j=0;$j<$TempDataSize;$j++)
							{
								$NewData[$j]=TextDB_FilterStr($TempData[$j],0);
								if($j>0)
								{
									$NewData[TextDB_FilterStr($TableFields[$j],0)] = TextDB_FilterStr($TempData[$j],0);
								}
								else
								{
									$NewData['TEXTDB_HID'] = TextDB_FilterStr($TempData[$j],0);
								}
							}
							$TempDataList[$k] = $NewData;
							unset($TempData,$NewData);
							$k+=1;
						}
					}
				}
			}

			//是否按照字段排序
			if(!empty($OrderFields) && isset($TempDataList))
			{
				$TempDataList = TextDB_OrderData($TempDataList,$OrderFields);
			}

			//检测是否返回数据，返回找到数据
			if(isset($TempDataList[0]['TEXTDB_HID']) || TextDB_CheckStr($TempTableName,_TextDB_SysTBSN_,1))
			{
				//判断数据数据取出顺序 并计算位置
				$Order = strtolower($Order);  //容错处理

				//数据大小
				$TempDataSize = sizeof($TempDataList);
				$n  = 0;

				//依照顺序，和数量调取
				if($Order=='asc')
				{
					//获取开始位置
					$StartNum = empty($StartNum) ? 0 : $StartNum;

					//获取结束位置
					$Number = empty($Number) ? $TempDataSize : $StartNum+$Number;
					$Number = $Number>$TempDataSize ? $TempDataSize : $Number;

					//结束位置必须大于等于开始位置
					if($Number<$StartNum)
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//列出数据
					for($i=$StartNum;$i<$Number;$i++)
					{
						$DataList[$n] = $TempDataList[$i];
						$IN = 1;
						$n++;
					}
				}
				elseif($Order=='desc')
				{
					//结束位置必须小于等于开始位置
					if($StartNum>$TempDataSize-1)
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//获取开始位置
					$StartNum = empty($StartNum) ? ($TempDataSize-1) : ($TempDataSize-$StartNum-1);
					$StartNum = $StartNum>0 ? $StartNum : 0 ;

					//获取结束位置
					$Number = empty($Number) ? 0 : $StartNum-$Number+1;
					$Number = $Number<=0 ? 0 : $Number;

					//结束位置必须小于等于开始位置
					if($Number>$StartNum)
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//列出数据
					for($i=$StartNum;$i>=$Number;$i--)
					{
						$DataList[$n] = $TempDataList[$i];
						$IN = 1;
						$n++;
					}
				}
				elseif($Order=='rand')
				{
					//打乱数据内容
					for($i=0;$i<$TempDataSize;$i++)
					{
						$randID = rand(0,$TempDataSize-1);
						if(empty($_TempList[$randID]['TEXTDB_HID']))
						{
							$_TempList[$randID] = $TempDataList[$i];
						}
						else
						{
							$i-=1;
						}
					}
					$TempDataList = $_TempList;
					unset($_TempList);


					//获取开始位置
					$StartNum = empty($StartNum) ? 0 : $StartNum;

					//获取结束位置
					$Number = empty($Number) ? $TempDataSize : $StartNum+$Number;
					$Number = $Number>$TempDataSize ? $TempDataSize : $Number;

					//结束位置必须大于等于开始位置
					if($Number<$StartNum)
					{
						//释放文件
						TextDB_UnlockTable($TempTableName);
						return false;
					}

					//列出数据
					for($i=$StartNum;$i<$Number;$i++)
					{
						$DataList[$n] = $TempDataList[$i];
						$IN = 1;
						$n++;
					}
				}
				else
				{
					//释放文件
					TextDB_UnlockTable($TempTableName);

					//未知排序
					return false;
				}

				//释放文件
				TextDB_UnlockTable($TempTableName);

				//返回数据
				unset($TempDataList);
				return $DataList;
			}
			else
			{
				//释放文件
				TextDB_UnlockTable($TempTableName);

				//无数据
				unset($TempDataList);
				return false;
			}
		}
		else
		{
			//未连接数据库
			return false;
		}
	}
	else
	{
		//TEXTDB未启动
		return false;
	}
}
?>